def BNL(len1, len2, dataArray):
    """
    This function takes in three parameters: len1, len2, and dataArray.
    It returns a list of indices of the dataArray that are greater than or equal to the corresponding values in dataArray.
    Find the unique sequence with the shortest length of 0s and 1s using the Binary Nearest Neighbor List (BNL) algorithm.

    Args:
    :param len1: (int)Length of the first sequence.
    :param len2: (int)Length of the second sequence.
    :param dataArray: (list)2D array of data containing the sequences.

    Returns:
    :return: list: List of indices corresponding to the unique sequence with the shortest length of 0s and 1s.

    Algorithm Overview:
    The BNL algorithm iterates through each sequence in the `data_array` and keeps track of a `resultList` that stores the indices
    of the unique sequences. Initially, the `resultList` is empty. For each sequence, it compares the values of the current
    sequence with those in the `resultList`. If the current sequence is better in all aspects (having more 1s or less 0s) than any
    sequence in the `resultList`, the sequence is added to the `resultList`. However, if the current sequence is worse in all aspects,
    it is considered redundant and not added to the `resultList`.

    The steps involved in the algorithm are as follows:
    - Initialize an empty `resultList`.
    - For each sequence `i` in the `data_array`:
        - If `resultList` is empty, add `i` to `resultList`.
        - Otherwise:
            - Initialize an empty `deleteList` to keep track of redundant sequences in the `resultList`.
            - Iterate through each sequence `j` in the `resultList`:
                - Count the number of times the current sequence `i` is better (`iQjCNT`) and worse (`jQiCNT`) than `j` in each aspect.
                - If `jQiCNT` is equal to the length of the sequence (`len2`), it means that `i` is worse than `j` in all aspects,
                  and hence, `i` is not added to the `resultList`. Break out of the loop.
                - If `iQjCNT` is equal to the length of the sequence (`len2`), it means that `i` is better than `j` in all aspects,
                  and hence, `j` is redundant. Add `j` to the `deleteList`.
            - If `deleteList` is not empty, remove the redundant sequences from the `resultList`.
            - If `i` is not redundant, add it to the `resultList`.

    Finally, return the `resultList` containing the indices of the unique sequence with the shortest length of 0s and 1s.
    """
    # Initialize the result list; Create a list to store the indices of the dataArray
    resultList = []
    # Iterate through the length of the dataArray
    for i in range(len1):
        # If the list is empty, add the current index to the list
        if len(resultList) == 0:
            resultList.append(i)
        # Otherwise, delete the indices from the list
        else:
            deleteList = []
            remain = True
            # Iterate through the list
            for j in resultList:
                # Initialize counters for the dataArray
                iQjCNT = 0
                jQiCNT = 0
                # Iterate through the dataArray; Compare the values of the current data with those of existing data
                for t in range(len2):
                    # If the dataArray is greater than the current index, increment the jQiCNT counter
                    if float(dataArray[i][t]) >= float(dataArray[j][t]):
                        iQjCNT += 1
                    # If the dataArray is less than the current index, increment the iQjCNT counter
                    if float(dataArray[i][t]) <= float(dataArray[j][t]):
                        jQiCNT += 1
                # If the jQiCNT counter is equal to the length of the dataArray, the index is not in the list; If the current data is worse than an existing data in all aspects, it is not valid
                if jQiCNT == len2:
                    remain = False
                    break
                # If the iQjCNT counter is equal to the length of the dataArray, the index is in the list; If the current data is better than an existing data in all aspects, the existing data will be deleted
                if iQjCNT == len2:
                    deleteList.append(j)
            # If the list is not empty, delete the indices from the list; Remove the deleted data from the result list
            if len(deleteList) > 0:
                resultList = [resultList[p] for p in range(len(resultList)) if p not in deleteList]
            # If the index is not in the list, add it to the list; If the current data is valid, add it to the result list
            if remain:
                resultList.append(i)
    # Return the list of indices
    return resultList